package com.jinzhu.service.impl;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.jinzhu.emums.CommentLevel;
import com.jinzhu.mapper.*;


import com.jinzhu.mapper.custom.ItemsMapperCustom;
import com.jinzhu.pojo.*;

import com.jinzhu.service.ItemsService;

import com.jinzhu.utils.DesensitizationUtil;
import com.jinzhu.utils.PagedGridResult;
import com.jinzhu.vo.CommentLevelCountsVO;
import com.jinzhu.vo.ItemCommentVO;
import com.jinzhu.vo.SearchItemsVO;
import com.jinzhu.vo.ShopcartVO;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;


/**
 * 商品展示
 * jinzhu
 */
@Service
public class ItemsServiceImpl implements ItemsService {

    @Autowired
    private ItemsSpecMapper itemsSpecMapper;
    @Autowired
    private ItemsParamMapper itemsParamMapper;
    @Autowired
    private ItemsMapper itemsMapper;
    @Autowired
    private ItemsImgMapper itemsImgMapper;
    @Autowired
    private ItemsCommentsMapper itemsCommentsMapper;
    @Autowired
    private ItemsMapperCustom itemsMapperCustom;
    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 根据商品id查询商品详情
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     *
     * @param id
     * @return
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public Items queryItemsById(String itemId) {
        return itemsMapper.selectById(itemId);
    }


    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 根据商品id查询商品图片列表
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     *
     * @param id
     * @return
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public List<ItemsImg> queryItemsImgList(String itemId) {
        return itemsImgMapper.selectList(new QueryWrapper<ItemsImg>()
                .lambda()
                .eq(ItemsImg::getItemId, itemId));
    }


    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 根据商品id查询商品规格列表
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     *
     * @param id
     * @return
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public List<ItemsSpec> queryItemsSpecList(String itemId) {
        return itemsSpecMapper.selectList(new QueryWrapper<ItemsSpec>()
                .lambda()
                .eq(ItemsSpec::getItemId, itemId));
    }


    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 根据商品id查询商品参数
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     *
     * @param id
     * @return
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public ItemsParam queryItemsParamByItemId(String itemId) {
        return itemsParamMapper.selectOne(new QueryWrapper<ItemsParam>()
                .lambda()
                .eq(ItemsParam::getItemId, itemId));
    }


    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     * 根据商品id查询商品的评价等级数量
     *
     * @param itemId
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public CommentLevelCountsVO queryCommentCounts(String itemId) {
        Integer goodCounts = getCommentCounts(itemId, CommentLevel.GOOD.type);
        Integer normalCounts = getCommentCounts(itemId, CommentLevel.NORMAL.type);;
        Integer badCounts = getCommentCounts(itemId, CommentLevel.BAD.type);
        Integer totalCounts = goodCounts + normalCounts + badCounts;
        CommentLevelCountsVO countsVO = new CommentLevelCountsVO();
        countsVO.setTotalCounts(totalCounts);
        countsVO.setGoodCounts(goodCounts);
        countsVO.setNormalCounts(normalCounts);
        countsVO.setBadCounts(badCounts);
        return countsVO;
    }

    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     * 根据商品id查询商品的评价等级数量
     *
     * @param itemId
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    public Integer getCommentCounts(String itemId, Integer level) {
        return itemsCommentsMapper.selectCount(new QueryWrapper<ItemsComments>()
                .lambda()
                .eq(ItemsComments::getItemId, itemId)
                .eq(ItemsComments::getCommentLevel, level));
    }


    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     * 根据商品id查询商品的用户评价---分页
     *
     * @param itemId
     * @param level
     * @param page
     * @param pageSize
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public PagedGridResult queryPagedComments(String itemId,
                                              Integer level,
                                              Integer page,
                                              Integer pageSize) {

        Map<String, Object> map = new HashMap<>();
        map.put("itemId", itemId);
        map.put("level", level);

        // mybatis-pagehelper

        /**
         * page: 第几页
         * pageSize: 每页显示条数
         */
        PageHelper.startPage(page, pageSize);
        //SuppressWarnings  用于避免出现约束错误 但是实际有可能还是会出先
        @SuppressWarnings("checked")  List<ItemCommentVO> list = itemsMapperCustom.queryItemComments(map);
        for (ItemCommentVO vo : list) {
            vo.setNickname(DesensitizationUtil.commonDisplay(vo.getNickname()));

        }
        return setterPagedGrid(list, page);
    }

    /**
     * @Transactional(propagation = Propagation.SUPPORTS)
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     * @param username 根据三级分类id搜索商品列表
     * @return IMOOCJSONResult
     * <p>
     * 搜索商品列表                                                                                                                  是否存在
     * @author jinzhu
     * @date 2021-05-06
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public PagedGridResult searhItems(String keywords, String sort, Integer page, Integer pageSize) {

        Map<String, Object> map = new HashMap<>();
        map.put("keywords", keywords);
        map.put("sort", sort);

        PageHelper.startPage(page, pageSize);

        List<SearchItemsVO> list = itemsMapperCustom.searchItems(map);
        return setterPagedGrid(list, page);
    }

    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     * 根据商品id查询商品的用户评价---分页
     *
     * @param itemId
     * @param level
     * @param page
     * @param pageSize
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public PagedGridResult searhItems(Integer catId, String sort, Integer page, Integer pageSize) {

        Map<String, Object> map = new HashMap<>();
        map.put("catId", catId);
        map.put("sort", sort);

        PageHelper.startPage(page, pageSize);
        List<SearchItemsVO> list = itemsMapperCustom.searchItemsByCatId(map);

        return setterPagedGrid(list, page);
    }

    /**
     *  @Transactional(propagation = Propagation.SUPPORTS)
     * 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
     * 根据规格ids查询最新的购物车中商品数据（用于刷新渲染购物车中的商品数据）
     * @param specIds
     * @return
     * @author jinzhu
     * @date 2021-05-06
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public List<ShopcartVO> queryItemsBySpecIds(String specIds) {

        String ids[] = specIds.split(",");
        List<String> specIdsList = new ArrayList<>();
        Collections.addAll(specIdsList, ids);

        return itemsMapperCustom.queryItemsBySpecIds(specIdsList);
    }

    /**
     *
     * List<?> 表示站位符 可以存任何不确定类型  一般用于声明和使用
     * List<T> 表示泛型但是是强制转换 系统严谨出转换容易出错 可以存任何不确定类型 、用于声明
     * List<Class> 表示不确定的对象 可以用它就是编译后端对象不知道是某个
     * 分页工具类
     * @param list
     * @param page
     * @return
     */
    private PagedGridResult setterPagedGrid(List<?> list, Integer page) {
        PageInfo<?> pageList = new PageInfo<>(list);
        PagedGridResult grid = new PagedGridResult();
        grid.setPage(page);
        grid.setRows(list);
        grid.setTotal(pageList.getPages());
        grid.setRecords(pageList.getTotal());
        return grid;
    }
}
